Python 中有多种实现堆栈排序的方法，以下是一种使用 heapq 模块实现的方法：
```
import heapq

def heap_sort(arr):
    # 创建一个空堆
    heap = []
    # 将数组中的元素 push 到堆中
    for num in arr:
        heapq.heappush(heap, num)
    # 将堆中的元素 pop 出来，并将其 push 到一个新的数组中
    sorted_arr = []
    while heap:
        sorted_arr.append(heapq.heappop(heap))
    return sorted_arr
```
这个方法的时间复杂度是 O(n log n)，空间复杂度是 O(n)，其中 n 是数组的长度。

下面是一个使用 collections.deque 实现的方法：
```
from collections import deque

def heap_sort(arr):
    # 创建一个空栈
    stack = deque()
    # 将数组中的元素 push 到栈中
    for num in arr:
        stack.append(num)
    # 将栈中的元素 pop 出来，并将其 push 到一个新的数组中
    sorted_arr = []
    while stack:
        sorted_arr.append(stack.pop())
    return sorted_arr
```
这个方法的时间复杂度是 O(n)，空间复杂度是 O(n)，其中 n 是数组的长度。

下面是一个使用 recursion 实现的方法：
```
def heap_sort(arr):
    if len(arr) <= 1:
        return arr
    max_idx = 0
    for i in range(1, len(arr)):
        if arr[i] > arr[max_idx]:
            max_idx = i
    arr[0], arr[max_idx] = arr[max_idx], arr[0]
    return heap_sort(arr[1:]) + [arr[0]]
```
这个方法的时间复杂度是 O(n log n)，空间复杂度是 O(n)，其中 n 是数组的长度。

这些方法都可以用来实现堆栈排序，但是 heapq 模块的实现可能是最快的。